import { MP_KEY } from "@/config/init";

export function getLocation() {
  return new Promise((resolve, reject) => {
    uni.getLocation({
      type: "wgs84",
      geocode: true, // 设置该参数为 true 可直接获取经纬度及城市信息
      success: function (res) {
        resolve(res);
      },
      fail: function (err) {
        uni.showToast({
          title: "获取地址失败，将导致部分功能不可用",
          icon: "none",
        });
        resolve("error");
      },
    });
  });
}

export function getFuzzyLocation() {
  return new Promise((resolve, reject) => {
    uni.getFuzzyLocation({
      type: "wgs84",
      geocode: true, // 设置该参数为 true 可直接获取经纬度及城市信息
      success: function (res) {
        resolve(res);
      },
      fail: function (err) {
        uni.showToast({
          title: "获取地址失败，将导致部分功能不可用",
          icon: "none",
        });
        resolve("error");
      },
    });
  });
}

// 腾讯地图逆地址解析
export function getAddress(latitude, longitude) {
  return new Promise((resolve, reject) => {
    uni.request({
      url: "https://apis.map.qq.com/ws/geocoder/v1/",
      method: "GET",
      data: {
        location: `${latitude},${longitude}`,
        key: MP_KEY,
      },
      success: function (res) {
        resolve(res);
      },
      fail: function () {
        uni.showToast({
          title: "获取地址失败",
          icon: "none",
        });
        reject("error");
      },
    });
  });
}

// 跳转地图
export function goToMap(latitude, longitude, name, address) {
  uni.openLocation({
    latitude,
    longitude,
    name,
    address,
  });
}

// 上传图片
export function uploadImage(limit = 1) {
  uni.chooseImage({
    count: limit,
    sizeType: ["original", "compressed"],
    sourceType: ["album", "camera"],
    success: function (res) {
      uni.uploadFile({
        url: "https://example.com/upload", // 上传图片的服务器地址
        filePath: res.tempFilePaths[0],
        name: "file",
        formData: {
          user: "test",
        },
        success: function (res) {
          console.log(res);
        },
      });
    },
  });
}

/**
 * 日期格式化高级封装
 * @param {number|string|Date} date - 时间戳/日期字符串/Date对象
 * @param {string} [format='YYYY/MM/DD'] - 格式模板
 * @returns {string} 格式化后的日期
 */

export function formatDateTime(date, format = "YYYY-MM-DD") {
  let d = date;
  if (!(d instanceof Date)) {
    d = new Date(Number(d));
  }

  const pad = (num) => String(num).padStart(2, "0");

  const replacements = {
    YYYY: d.getFullYear(),
    YY: String(d.getFullYear()).slice(-2),
    MM: pad(d.getMonth() + 1),
    DD: pad(d.getDate()),
    HH: pad(d.getHours()),
    mm: pad(d.getMinutes()),
    ss: pad(d.getSeconds()),
  };

  return format.replace(
    /YYYY|YY|MM|DD|HH|mm|ss/g,
    (match) => replacements[match]
  );
}

export function getElementHeight(selector) {
  return new Promise((resolve) => {
    uni
      .createSelectorQuery()
      .select(selector)
      .boundingClientRect((rect) => {
        resolve(rect ? rect.height : 0);
      })
      .exec();
  });
}

/**
 * 节流函数
 * @param fn 需要执行的函数
 * @param time 间隔时间
 * @returns
 */
export const throttle = (func, wait) => {
  let timeout; // 定义一个计时器变量，用于限制函数调用频率
  return function (...args) {
    // 返回一个包装后的函数
    const context = this; // 保存函数执行上下文对象
    if (!timeout) {
      // 如果计时器不存在
      func.apply(context, args); // 执行函数
      timeout = setTimeout(() => {
        timeout = null; // 清空计时器变量
      }, wait); // 创建计时器，在指定时间后重置计时器变量
    }
  };
};

/**
 * 防抖函数
 * @param fn 需要执行的函数
 * @param time 间隔时间
 * @returns
 */
export const debounce = (func, wait, immediate) => {
  let timeout; // 定义一个计时器变量，用于延迟执行函数
  return function (...args) {
    // 返回一个包装后的函数
    const context = this; // 保存函数执行上下文对象
    const later = function () {
      // 定义延迟执行的函数
      timeout = null; // 清空计时器变量
      if (!immediate) func.apply(context, args); // 若非立即执行，则调用待防抖函数
    };
    const callNow = immediate && !timeout; // 是否立即调用函数的条件
    clearTimeout(timeout); // 清空计时器
    timeout = setTimeout(later, wait); // 创建新的计时器，延迟执行函数
    if (callNow) func.apply(context, args); // 如果满足立即调用条件，则立即执行函数
  };
};

// utils/screen.js
export function getRemainingHeightAsync(selector = null) {
  return new Promise((resolve) => {
    try {
      const systemInfo = uni.getSystemInfoSync();
      let remainingHeight = systemInfo.windowHeight;

      // 减去状态栏高度（可选）
      remainingHeight -= systemInfo.statusBarHeight || 0;

      if (!selector) {
        return resolve(remainingHeight);
      }

      // 异步获取元素高度
      uni
        .createSelectorQuery()
        .select(selector)
        .boundingClientRect((rect) => {
          if (rect) {
            remainingHeight -= rect.height;
          }
          resolve(remainingHeight);
        })
        .exec();
    } catch (error) {
      console.error("获取屏幕高度失败:", error);
      resolve(0);
    }
  });
}
